home *** CD-ROM | disk | FTP | other *** search
/ Developer CD Series 1997 July: Mac OS SDK / Dev.CD Jul 97 SDK1.toast / Development Kits (Disc 1) / QuickDraw GX / Programming Stuff / Sample Code / Printing Samples / Printer Drivers… / ImageWriterLQ (alt. rdip) / DialogRoutines.c < prev    next >
Encoding:
Text File  |  1996-06-15  |  22.1 KB  |  810 lines  |  [TEXT/MPS ]
  1. /*---------------------------------------------------------------------------
  2. FILENAME
  3.     DialogRoutines.c
  4.  
  5. DESCRIPTION
  6.     This file contains the routines which are used to process the LQ driver's
  7.     sheetfeeder dialog.
  8.         
  9. COPYRIGHT
  10.     Copyright Apple Computer, Inc. 1992-1996
  11.     All rights reserved. 
  12.     
  13. INTERFACE ROUTINES:
  14.     DoSheetfeederDialog
  15.  
  16.     12/20/93        dmh                Sync'd with the shipping 1.0b3 GX driver.
  17.      8/28/94        dmh                Sync'd with the shipping 1.0.1 GX driver.
  18.      6/14/96        cn                    Updated to support Universal Interfaces 2.1.
  19.  
  20. -------------------------------------------------------------------------------- */
  21.  
  22. // Include the standard Mac header files 
  23. #include "MacIncludes.h"
  24.  
  25. // Include the new QuickDraw GX graphics header files 
  26. #include <GXGraphics.h>
  27. #include <GraphicsLibraries.h>
  28. #include <GXMath.h>
  29. #include <QDLibrary.h>
  30.  
  31. // Include the required Printing Manager header files 
  32. #include <GXPrinting.h>
  33. #include <GXPrinterDrivers.h>
  34. #include <Collections.h>
  35. #include <GXMessages.h>
  36.  
  37. #include <GXExceptions.h>
  38.  
  39. // Include the internal driver constants and types used by this module 
  40. #include "LQResources.h"
  41. #include "UniversalMessageIntf.h"
  42. #include "DialogRoutines.h"
  43.  
  44.  
  45. /***************************************************************************************
  46. *                                                 CONSTANTS                                                         *
  47. ***************************************************************************************/                        
  48.  
  49. // Constants for accessing items in the Sheetfeeder dialog
  50.  
  51. #define    kTray1Item                4            //    Tray #1 pop-up menu
  52. #define    kTray2Item                5            //    Tray #2 pop-up menu
  53. #define    kTray3Item                6            //    Tray #3 pop-up menu
  54. #define    kPrinterPICTItem        7            //    Picture of the printer with a sheetfeeder
  55.  
  56. // Constants useful for filtering events
  57.  
  58. #define    kENTER                    0x03        // ENTER character
  59. #define    kCR                        0x0D        // Carriage return character
  60.  
  61. // Constants defining the maximum paper size supported by the LQ printer
  62.  
  63. #define    kMaxPaperWidth            ff(15)    // 15 inches is maximum width
  64. #define    kMaxPaperHeight        ff(69)    // 69 inches is maximum height
  65.  
  66.  
  67. /*********************************************************************************
  68.  *                                             TYPES                                                     *
  69.  *********************************************************************************/
  70.  
  71. // PopupMenuInfo - Structure used to initialize the tray pop-up menus 
  72.  
  73. typedef struct
  74. {
  75.     short                numTrays;        // Number of trays configured on the printer 
  76.     MenuHandle        tray1Menu;        //    handle to the tray #1 pop-up menu
  77.     MenuHandle        tray2Menu;        //    handle to the tray #2 pop-up menu
  78.     MenuHandle        tray3Menu;        //    handle to the tray #3 pop-up menu
  79. }    PopupMenuInfo,
  80.     *PopupMenuInfoPtr;
  81.     
  82.     
  83. // PaperSearchRec - Structure used to search for a paper type chosen from a pop-up menu
  84.  
  85. typedef struct
  86. {
  87.     gxPaperType        paper;            // temp. paper type reference in which to return found paper type 
  88.     Str31                paperName;        //    name of the paper to locate
  89. }    PaperSearchRec,
  90.     *PaperSearchRecPtr;
  91.     
  92.  
  93. /***************************************************************************************
  94. *                                         INLINE ROUTINES                                                         *
  95. ***************************************************************************************/                        
  96.  
  97. pascal void QDDrawPicture(PicHandle myPicture,const Rect *dstRect) = 0xA8F6;
  98.  
  99.  
  100. /***************************************************************************************
  101. *                                         INTERNAL ROUTINES                                                     *
  102. ***************************************************************************************/                        
  103.  
  104.  
  105. /****************************************************************************************
  106.  
  107.                             FindChosenPaperType
  108.                             
  109.     function:
  110.                 This routine is called by ForEachPaperTypeDo, and it searches for a specific
  111.                 paper type (by name).  It terminates searching when the paper type is 
  112.                 found.  Only the names of paper that will fit into the printer will be considered.
  113.  
  114.                 
  115.     parameters:                
  116.                 paper                target paper type
  117.                 paperToFind        structure that identifies the paper type to find
  118.                 
  119.     returns:
  120.                 LoopStatus        keepLooping => keep examining paper types
  121.                                     stopLooping    => no longer loop - we found the one we wanted
  122.     
  123. ****************************************************************************************/
  124. pascal gxLoopStatus FindChosenPaperType(gxPaperType paper, PaperSearchRecPtr paperToFind)
  125. {
  126.     Str31                paperName;
  127.     gxLoopStatus    status = gxKeepLooping;
  128.     gxRectangle        paperSize;
  129.     
  130.     // Get the dimensions of the paper
  131.     GXGetPaperTypeDimensions(paper, nil, &paperSize);
  132.     
  133.     // Will the paper fit into the printer?
  134.     if (    ( (paperSize.right - paperSize.left) <= FixMul(ff(72), kMaxPaperWidth) )    &&
  135.             ( (paperSize.bottom - paperSize.top) <= FixMul(ff(72), kMaxPaperHeight) )
  136.         )
  137.     {
  138.         // Retrieve the name of the paper type
  139.         GXGetPaperTypeName(paper, paperName);
  140.     
  141.         if ( IUCompString(paperName, paperToFind->paperName) == 0 )    //    T => Found the paper type
  142.         {
  143.             // Make a copy of this paper type and quit searching
  144.             GXCopyPaperType (paper, paperToFind->paper);
  145.             status = gxStopLooping;
  146.         }
  147.     }
  148.         
  149.     return(status);
  150. } 
  151. /* FindChosenPaperType */
  152.  
  153.  
  154. /****************************************************************************************
  155.  
  156.                             SaveSheetfeederSettings
  157.                             
  158.     function:
  159.                 This routine is called if the user confirms the changes in the dialog.  It
  160.                 stores updates the tray information configuration file with the user's latest
  161.                 settings.
  162.                 
  163.     parameters:                
  164.                 theDlog        pointer to the target dialog
  165.                 menuStuff    info. about the pop-up menus
  166.                 
  167.     returns:
  168.                 OSErr            error code
  169.     
  170. ****************************************************************************************/
  171. OSErr SaveSheetfeederSettings(DialogPtr theDlog, PopupMenuInfoPtr menuStuff)
  172. {
  173.     OSErr            anErr;
  174.     gxPaperType    paper;
  175.     gxJob            theJob = GXGetJob();
  176.     MenuHandle    *nextMenu;
  177.     short            i;
  178.     
  179.     // Create a temporary paper type
  180.     
  181.     paper = GXNewPaperType(theJob, NULL, NULL, NULL);
  182.     anErr = GXGetJobError(theJob);
  183.     require(anErr == noErr, NewPaperType);
  184.     
  185.     // For each visible pop-up menu, update its associated tray information
  186.     
  187.     for (i = kTray1Item, nextMenu = &(menuStuff->tray1Menu); i <= kTray3Item; ++i, ++nextMenu )
  188.     {
  189.         short        whichTray = i - kTray1Item + 1;
  190.         
  191.         if ( whichTray <= menuStuff->numTrays )    //    T => This menu is visible
  192.         {
  193.             Str31                    paperName;
  194.             short                    itemType;
  195.             ControlHandle        item;
  196.             Rect                    itemRect;
  197.             PaperSearchRec        paperToFind;
  198.             
  199.             // Get the name of the chosen paper type from the menu
  200.             
  201.             GetDItem(theDlog, i, &itemType, (Handle *) &item, &itemRect);
  202.             GetItem(*nextMenu, GetCtlValue(item), paperName);
  203.  
  204.             // Get the tray information for this tray
  205.             
  206.             anErr = GXGetTrayPaperType(whichTray, paper);
  207.             if (anErr == resNotFound)
  208.                 anErr = noErr;
  209.             require(anErr == noErr, GetTrayPaperType);
  210.         
  211.             //    Get the referenced paper type
  212.  
  213.             paperToFind.paper = paper;
  214.             BlockMove((Ptr) paperName, (Ptr) paperToFind.paperName, sizeof(Str31));
  215.             
  216.             GXForEachJobPaperTypeDo(theJob, (gxPaperTypeProc) FindChosenPaperType, &paperToFind, false);        // Don't consider the format device in this search    
  217.             anErr = GXGetJobError(theJob);
  218.             require(anErr == noErr, ForEachPaperTypeDo);
  219.             
  220.             // Update the paper type for this tray
  221.             
  222.             anErr = GXSetTrayPaperType(whichTray, paper);
  223.             require(anErr == noErr, SetTrayPaperType);
  224.             
  225.         }
  226.         else    //     T => No more visible pop-up menus
  227.             break;
  228.     }
  229.  
  230.  
  231. /******* Clean-up *******/
  232.  
  233. SetTrayPaperType:
  234. GetTrayPaperType:
  235. ForEachPaperTypeDo:
  236.     GXDisposePaperType(paper);
  237.  
  238. NewPaperType:
  239.     return(anErr);
  240. }
  241. /* SaveSheetfeederSettings */
  242.  
  243.  
  244. /****************************************************************************************
  245.  
  246.                             SheetfeederDialogFilter
  247.                             
  248.     function:
  249.                 This routine is the filter proc. that is passed to ModalDialog when the 
  250.                 sheetfeeder dialog is displayed.  It filters for the <cr> and <enter> keys
  251.                 and for command-".".
  252.                 
  253.     parameters:                
  254.                 theDlog        pointer to the target dialog
  255.                 theEvent        the event to be filtered
  256.                 itemHit        the item which was selected; may be mapped to ok or cancel
  257.                 
  258.     returns:
  259.                 Boolean        true if we've filtered the event; false if ModalDialog should process it
  260.     
  261. ****************************************************************************************/
  262. pascal Boolean SheetfeederDialogFilter(DialogPtr theDlog, EventRecord *theEvent, short *itemHit)
  263. {
  264.     Boolean    eventFiltered = false;
  265.     short        itemType;
  266.     Rect        itemRect;
  267.     Handle    item;
  268.     
  269.     if ( (theEvent->what == keyDown) || (theEvent->what == autoKey) ) 
  270.     {
  271.         char        c;
  272.         
  273.         c = (char) (theEvent->message & charCodeMask);
  274.         
  275.         if ( (c == kCR) || (c == kENTER) )     //    T => User typed carriage return or enter key; filter event
  276.         {
  277.             *itemHit = ok;
  278.             eventFiltered = true;
  279.         }
  280.         else
  281.         if ( (c == '.') && ((theEvent->modifiers & cmdKey) != 0) )    //    T => User typed <cmnd>-"."
  282.         {
  283.             *itemHit = cancel;
  284.             eventFiltered = true;
  285.         }
  286.         
  287.         if (eventFiltered)    //    T => Highlight the buttons appropriately
  288.         {
  289.             ControlHandle    theCtrl;
  290.             long                ignore;
  291.             
  292.             // Highlight the OK button momentarily
  293.             
  294.             GetDItem(theDlog, *itemHit, &itemType, (Handle *) &theCtrl, &itemRect);
  295.             HiliteControl(theCtrl, inButton);
  296.             Delay(10, &ignore);
  297.             HiliteControl(theCtrl, 0);
  298.         }
  299.     }
  300.     else
  301.     if (theEvent->what == updateEvt)    //    T => Outline the OK button
  302.     {
  303.         GrafPtr    oldPort;
  304.         
  305.         GetPort(&oldPort);
  306.         SetPort(theDlog);
  307.         
  308.         GetDItem(theDlog, ok, &itemType, &item, &itemRect);
  309.         PenSize(3, 3);
  310.         InsetRect(&itemRect, -4, -4);
  311.         FrameRoundRect(&itemRect, 16, 16);
  312.         PenNormal();
  313.  
  314.         SetPort(oldPort);
  315.     }
  316.  
  317.     return(eventFiltered);
  318. }
  319. /* SheetfeederDialogFilter */
  320.  
  321.  
  322. /****************************************************************************************
  323.  
  324.                             UniquePaperName
  325.                             
  326.     function:
  327.                 This routine searches for a specified paper type name in a specific pop-up
  328.                 menu.  If it finds the name, the routine returns false; otherwise it
  329.                 returns true.
  330.                 
  331.     parameters:                
  332.                 hMenu            handle to the menu to examine
  333.                 paperName    name of the paper type to insert to check for
  334.                 
  335.     returns:
  336.                 Boolean        true if paper type name is unique; false otherwise
  337.     
  338. ****************************************************************************************/
  339. Boolean UniquePaperName(MenuHandle hMenu, Str31 paperName)
  340. {
  341.     Boolean    isUnique = true;
  342.     short        i;
  343.     Str255    menuString;
  344.     
  345.     for (i = CountMItems(hMenu); i > 0; --i) 
  346.     {
  347.         GetItem(hMenu, i, menuString);
  348.         
  349.         if ( IUCompString(paperName, menuString) == 0 )     //    T => Found the string
  350.         {
  351.             isUnique = false;
  352.             break;
  353.         }
  354.     }
  355.     
  356.     return(isUnique);
  357. }  
  358. /* UniquePaperName */
  359.  
  360.  
  361. /****************************************************************************************
  362.  
  363.                             AddPaperName
  364.                             
  365.     function:
  366.                 This routine is called by ForEachPaperTypeDo, and it adds a paper name to 
  367.                 each visible pop-up menu if the name does not already appear in the menu.
  368.                 Only the names of paper that will fit into the printer will be listed
  369.                 in the pop-up menu.
  370.                 
  371.     parameters:                
  372.                 paper                target paper type
  373.                 menuStuff        pointer to info about the dialog's pop-up menus
  374.                 
  375.     returns:
  376.                 LoopStatus        keepLooping => examine all target paper types
  377.     
  378. ****************************************************************************************/
  379. pascal gxLoopStatus AddPaperName(gxPaperType paper, PopupMenuInfoPtr menuStuff)
  380. {
  381.     Str31            paperName;
  382.     gxRectangle    paperSize;
  383.     
  384.     // Get the dimensions of the paper
  385.     GXGetPaperTypeDimensions(paper, nil, &paperSize);
  386.     
  387.     // Will the paper fit into the printer?
  388.     if (    ( (paperSize.right - paperSize.left) <= FixMul(ff(72), kMaxPaperWidth) )    &&
  389.             ( (paperSize.bottom - paperSize.top) <= FixMul(ff(72), kMaxPaperHeight) )
  390.         )
  391.     {
  392.         // Retrieve the name of the paper type
  393.         GXGetPaperTypeName(paper, paperName);
  394.     
  395.         if ( UniquePaperName(menuStuff->tray1Menu, paperName) )    //    T => If the paper name is unique, add it
  396.         {
  397.             MenuHandle        *nextMenu;
  398.             Str255            theName;
  399.             short                i;
  400.             
  401.             // For each visible menu, add the name to the pop-up
  402.             
  403.             for (i = kTray1Item, nextMenu = &(menuStuff->tray1Menu); i <= kTray3Item; ++i, ++nextMenu )
  404.             {
  405.                 if ( (i - kTray1Item + 1) <= menuStuff->numTrays )    //    T => This menu is visible
  406.                 {
  407.                     AppendMenu(*nextMenu, "\p ");
  408.                     BlockMove(paperName, theName, sizeof(Str31));
  409.                     SetItem(*nextMenu, CountMItems(*nextMenu), theName);
  410.                 }
  411.                 else    //     T => No more visible pop-up menus
  412.                     break;
  413.             }
  414.         }
  415.     }
  416.         
  417.     return (gxKeepLooping);
  418. } 
  419. /* AddPaperName */
  420.  
  421.  
  422. /****************************************************************************************
  423.  
  424.                             LoadPaperNames
  425.                             
  426.     function:
  427.                 This routine loads the names of each uniquely named paper type into each of the
  428.                 tray pop-up menus that are still visible.
  429.                 
  430.     parameters:                
  431.                 pDlg            Pointer to the target dialog
  432.                 whichItem    Index in the DITL of the item to draw
  433.                 
  434.     returns:
  435.                 OSErr            error code
  436.     
  437. ****************************************************************************************/
  438. OSErr LoadPaperNames(DialogPtr theDlog, PopupMenuInfoPtr menuStuff)
  439. {
  440.     short                itemType;
  441.     Rect                itemRect;
  442.     ControlHandle    item;
  443.     short                i;
  444.     gxJob                theJob = GXGetJob();
  445.     OSErr                anErr;
  446.  
  447.     GXForEachJobPaperTypeDo(theJob,  (gxPaperTypeProc) AddPaperName,  menuStuff, false);        // Don't consider the format device in this search    
  448.     anErr = GXGetJobError(theJob);
  449.  
  450.     if (anErr == noErr)
  451.     {
  452.         MenuHandle        *nextMenu;
  453.         
  454.         // For each visible menu, initialize the pop-up control
  455.         
  456.         for (i = kTray1Item, nextMenu = &(menuStuff->tray1Menu); i <= kTray3Item; ++i, ++nextMenu )
  457.         {
  458.             if ( (i - kTray1Item + 1) <= menuStuff->numTrays )    //    T => This menu is visible
  459.             {
  460.                 GetDItem(theDlog, i, &itemType, (Handle *) &item, &itemRect);
  461.                 
  462.                 SetCtlMin(item, 1);
  463.                 SetCtlMax(item, CountMItems(*nextMenu));
  464.                 SetCtlValue(item, 1);
  465.             }
  466.             else    //     T => No more visible pop-up menus
  467.                 break;
  468.         }
  469.     }
  470.  
  471.     return(anErr);
  472. }
  473. /* LoadPaperNames */
  474.  
  475.  
  476. /****************************************************************************************
  477.  
  478.                             SheetfeederDrawProc
  479.                             
  480.     function:
  481.                 This routine is used to draw the picture of the sheetfeeder in the configuration
  482.                 dialog.
  483.                 
  484.     parameters:                
  485.                 pDlg            Pointer to the target dialog
  486.                 whichItem    Index in the DITL of the item to draw
  487.                 
  488.     returns:
  489.                 OSErr            error code
  490.     
  491. ****************************************************************************************/
  492. pascal void SheetfeederDrawProc(WindowPtr    pDlg, short whichItem)
  493. {
  494.     SpecGlobalsHdl     hGlobals = GetMessageHandlerInstanceContext();
  495.     Handle                hItem;
  496.     Rect                    itemRect;
  497.     short                    itemType;
  498.     
  499.     GetDItem(pDlg, whichItem, &itemType, &hItem, &itemRect);
  500.  
  501.     QDDrawPicture((*hGlobals)->sheetFeederPICT, &itemRect);
  502. }
  503. /* SheetfeederDrawProc */
  504.  
  505.  
  506. /****************************************************************************************
  507.  
  508.                             GetConfigInfo
  509.                             
  510.     function:
  511.                 This routine is a utility function that returns the LQ driver's configuration
  512.                 info. from the desktop printer file.
  513.                 
  514.     parameters:                
  515.                 configInfo    Latest info fetched from the DTP file
  516.                 
  517.     returns:
  518.                 OSErr            error code
  519.     
  520. ****************************************************************************************/
  521. OSErr GetConfigInfo(IWLQConfigInfoPtr configInfo)
  522. {
  523.     OSErr                        anErr;
  524.     Str32                        deviceName;
  525.     IWLQConfigInfoHdl        hConfigData;
  526.     
  527.     // Get the name of the desktop printer file
  528.     GXGetPrinterName(GXGetJobOutputPrinter(GXGetJob()), deviceName);
  529.  
  530.     // Get the config info
  531.     anErr = GXFetchDTPData(deviceName, kIWLQConfigType, kIWLQConfigID, (Handle *) &hConfigData);
  532.     require(anErr == noErr, FetchDTPData);
  533.     
  534.     // Return the config. info
  535.     *configInfo = **hConfigData;
  536.     
  537.     // Kill the temporary handle
  538.     DisposHandle((Handle) hConfigData);
  539.     
  540.  
  541. /******* Clean-up *******/
  542.  
  543. FetchDTPData:
  544.     return(anErr);
  545. }
  546. /* GetConfigInfo */
  547.  
  548.  
  549. /****************************************************************************************
  550.  
  551.                             InitSheetfeederDialog
  552.                             
  553.     function:
  554.                 This routine is called to initialize the sheet feeder dialog and to set the
  555.                 state of the pop-up menus based upon the latest configuration information.
  556.                 
  557.     parameters:                
  558.                 theDlog        returns the pointer to the dialog window if init. was succesful; otherwise nil
  559.                 menuStuff    info about the dialog's pop-up menus
  560.                 
  561.     returns:
  562.                 OSErr        error code
  563.     
  564. ****************************************************************************************/
  565. OSErr InitSheetfeederDialog(DialogPtr *theDlog, PopupMenuInfoPtr menuStuff)
  566. {
  567.     OSErr                    anErr = noErr;
  568.     DialogPtr            dLog;
  569.     IWLQConfigInfo        configInfo;
  570.     SpecGlobalsHdl     hGlobals = GetMessageHandlerInstanceContext();
  571.     short                    itemType;
  572.     Rect                    itemRect;
  573.     Handle                hItem;
  574.     gxPaperType            paper;
  575.     
  576.     // Initialize variables
  577.     *theDlog = nil;
  578.     (*hGlobals)->sheetFeederPICT = nil;
  579.     
  580.     dLog = GetNewDialog(kSheetFeederDLOG, nil, (WindowPtr) (-1));
  581.     if (dLog == nil)
  582.     {
  583.         anErr = MemError();
  584.         if (anErr == noErr)
  585.             anErr = resNotFound;
  586.         
  587.         require(anErr == noErr, GetNewDialog);
  588.     }
  589.  
  590.     // Fetch the latest configuration info. from the DTP file
  591.     anErr = GetConfigInfo(&configInfo);
  592.     require(anErr == noErr, GetConfigInfo);
  593.     
  594.     // Determine which sheetfeeder picture to display in the dialog
  595.     {
  596.         short            whichPICT;
  597.         Handle        thePICT;
  598.         
  599.         switch (configInfo.numTrays)
  600.         {
  601.             case 1:    whichPICT = kOneTrayPICT;         break;
  602.             case 2:    whichPICT = kTwoTrayPICT;         break;
  603.             case 3:    whichPICT = kThreeTrayPICT;     break;
  604.         }
  605.         
  606.         anErr = Send_GXFetchTaggedDriverData('PICT', whichPICT, (Handle *) &thePICT);
  607.         require(anErr == noErr, FetchTaggedDriverData);
  608.         
  609.         // Save this handle in our globals
  610.  
  611.         HNoPurge(thePICT);
  612.         (*hGlobals)->sheetFeederPICT = (PicHandle) thePICT;
  613.         
  614.         // Setup the DrawProc for this picture item
  615.         
  616.         GetDItem(dLog, kPrinterPICTItem, &itemType, &hItem, &itemRect);
  617.         SetDItem(dLog, kPrinterPICTItem, itemType, (Handle) SheetfeederDrawProc, &itemRect);
  618.     }
  619.     
  620.     // Now fill in the pop-up menu paper type names and hide any pop-ups that don't apply
  621.     // to the current configuration
  622.     {
  623.         PopupPrivateDataHandle    privData;
  624.         short                            i;
  625.         MenuHandle                    *nextMenu;
  626.         
  627.         // Hide those pop-ups which don't apply to the current configuration
  628.         if (configInfo.numTrays < 3)
  629.         {
  630.             HideDItem(dLog, kTray3Item);
  631.         }
  632.  
  633.         if (configInfo.numTrays < 2)
  634.         {
  635.             HideDItem(dLog, kTray2Item);
  636.         }
  637.         
  638.         // Init. the menuStuff structure in order to load the paper names into the pop-ups
  639.         
  640.         menuStuff->numTrays = configInfo.numTrays;
  641.  
  642.         for (i = kTray1Item, nextMenu = &(menuStuff->tray1Menu); i <= kTray3Item; ++i, ++nextMenu)
  643.         {
  644.             GetDItem(dLog, i, &itemType, &hItem, &itemRect);
  645.             privData = (PopupPrivateDataHandle) (* (ControlHandle) hItem)->contrlData;
  646.             *nextMenu = (*privData)->mHandle;
  647.         }
  648.         
  649.         // Now load the paper type names into the remaining pop-up menus
  650.         anErr = LoadPaperNames(dLog, menuStuff);
  651.         require(anErr == noErr, LoadPaperNames);
  652.     }
  653.     
  654.     // Retrieve the latest paper<->tray configuration and force the pop-up(s) to display the
  655.     // correct paper name (i.e. the last selected paper name).
  656.     {
  657.         gxJob            theJob = GXGetJob();
  658.         MenuHandle    *nextMenu;
  659.         short            i;
  660.         
  661.         // Create a temporary paper type
  662.         
  663.         paper = GXNewPaperType(theJob, NULL, NULL, NULL);
  664.         anErr = GXGetJobError(theJob);
  665.         require(anErr == noErr, NewPaperType);
  666.         
  667.         // For each visible pop-up menu, try to display the last choosen paper type
  668.         
  669.         for (i = kTray1Item, nextMenu = &(menuStuff->tray1Menu); i <= kTray3Item; ++i, ++nextMenu )
  670.         {
  671.             short        whichTray = i - kTray1Item + 1;
  672.             
  673.             if ( whichTray <= menuStuff->numTrays )    //    T => This menu is visible
  674.             {
  675.                 Str255    menuString;
  676.                 short        j;
  677.                 Str31        paperName;
  678.                 
  679.                 // Get the tray information for this tray
  680.                 
  681.                 anErr = GXGetTrayPaperType(whichTray, paper);
  682.                 if (anErr == resNotFound)
  683.                     anErr = noErr;
  684.                 else {
  685.                     require(anErr == noErr, GetTrayPaperType);
  686.                 
  687.                     // Fetch the name of the paper type
  688.                     GXGetPaperTypeName(paper, paperName);
  689.                     
  690.                     // For each paper name in the menu, try to find a match
  691.                     
  692.                     for (j = CountMItems(*nextMenu); j > 0; --j) 
  693.                     {
  694.                         GetItem(*nextMenu, j, menuString);
  695.                         
  696.                         if ( IUCompString(paperName, menuString) == 0 )     //    T => Found the string
  697.                         {
  698.                             //    Make this paper name the current pop-up menu selection
  699.                             
  700.                             GetDItem(dLog, i, &itemType, &hItem, &itemRect);
  701.                             SetCtlValue((ControlHandle) hItem, j);
  702.                             break;
  703.                         }
  704.                     }
  705.                 }
  706.             }
  707.             else    //     T => No more visible pop-up menus
  708.                 break;
  709.         }
  710.  
  711.         // Dump the temporary paper type
  712.         GXDisposePaperType(paper);
  713.     }
  714.     
  715.     *theDlog = dLog;
  716.     
  717.     return(anErr);
  718.     
  719.     
  720. /******* Clean-up *******/
  721.  
  722. GetTrayPaperType:
  723.     GXDisposePaperType(paper);
  724.  
  725. NewPaperType:
  726. LoadPaperNames:
  727.     DisposHandle((Handle) (*hGlobals)->sheetFeederPICT);
  728.     
  729. FetchTaggedDriverData:
  730. GetConfigInfo:
  731.     DisposDialog(dLog);
  732.     
  733. GetNewDialog:
  734.     return(anErr);
  735. }
  736. /* InitSheetfeederDialog */
  737.  
  738.  
  739. /***************************************************************************************
  740. *                                         INTERFACE ROUTINES                                                     *
  741. ***************************************************************************************/                        
  742.  
  743. /****************************************************************************************
  744.  
  745.                             DoSheetfeederDialog
  746.                             
  747.     function:
  748.                 This routine is called to display and process the LQ driver's sheetfeeder
  749.                 dialog.  This dialog is displayed when the user selects the "Input Trays…" menu
  750.                 item from the Finder menu.  This dialog allows the user to specify the type
  751.                 of paper that's contained within the printer's sheet feeder.
  752.                 
  753.     parameters:                
  754.                 None
  755.                 
  756.     returns:
  757.                 OSErr        error code
  758.     
  759. ****************************************************************************************/
  760. OSErr DoSheetfeederDialog(void)
  761. {
  762.     OSErr                    anErr = noErr;
  763.     GrafPtr                oldPort;
  764.     DialogPtr            theDlog;
  765.     short                    itemHit = 0;
  766.     PopupMenuInfo        menuStuff;
  767.     SpecGlobalsHdl     hGlobals = GetMessageHandlerInstanceContext();
  768.     
  769.     GetPort(&oldPort);
  770.     
  771.     // Initialize the dialog before displaying it
  772.     anErr = InitSheetfeederDialog(&theDlog, &menuStuff);
  773.     require(anErr == noErr, InitSheetfeederDialog);
  774.     
  775.     // Make sure the dialog is now visible
  776.     ShowWindow(theDlog);
  777.     SelectWindow(theDlog);
  778.     
  779.     // Process events in the window
  780.     while ( (itemHit != ok) && (itemHit != cancel) )
  781.     {
  782.        ModalDialog((ModalFilterProcPtr) SheetfeederDialogFilter, &itemHit);
  783.     }
  784.  
  785.     //    Do we need to save the new settings?
  786.     if (itemHit == ok)
  787.         anErr = SaveSheetfeederSettings(theDlog, &menuStuff);
  788.         
  789.     // Dump the dialog and picture handle
  790.     
  791.     if ( (*hGlobals)->sheetFeederPICT != nil )
  792.         DisposHandle((Handle) (*hGlobals)->sheetFeederPICT);
  793.         
  794.     DisposDialog(theDlog);
  795.     
  796.     SetPort(oldPort);
  797.  
  798.     return(anErr);
  799.     
  800.     
  801. /******* Clean-up *******/
  802.  
  803. InitSheetfeederDialog:
  804.     SetPort(oldPort);
  805.     
  806.     return(anErr);
  807. }
  808. /* DoSheetfeederDialog */
  809.  
  810.